/**
 * 固定更新管理器 - 统计模块（仅开发环境）
 * 
 * 此文件在生产环境打包时会被完全移除
 * 
 * @author AI Assistant
 * @date 2025-12-01
 */

import { Log } from "../../core/logger/LoggerGlobal";

/**
 * 性能统计数据结构
 */
export interface PerformanceStats {
    // 帧计数
    logicFrames: number;
    renderFrames: number;
    skippedFrames: number;
    
    // 时间统计
    totalLogicTime: number;
    totalRenderTime: number;
    maxLogicTime: number;
    maxRenderTime: number;
    
    // 性能指标
    currentLogicFPS: number;
    currentRenderFPS: number;
    averageLogicTime: number;
    averageRenderTime: number;
    
    // 最后更新时间
    lastStatsUpdate: number;
}

/**
 * 统计管理器（开发环境专用）
 * 
 * 特点：
 * - 仅在开发环境使用
 * - 生产环境打包时完全移除
 * - 零性能开销
 */
export class FixedUpdateStatsManager {
    private stats: PerformanceStats;
    private lastStatsResetTime: number = 0;
    private readonly STATS_UPDATE_INTERVAL = 1000; // 1秒更新一次统计
    
    constructor() {
        this.stats = this.createEmptyStats();
        this.lastStatsResetTime = Date.now();
        
        Log.ecs.debug('FixedUpdateStatsManager 已创建（开发环境）');
    }
    
    /**
     * 创建空统计数据
     */
    private createEmptyStats(): PerformanceStats {
        return {
            logicFrames: 0,
            renderFrames: 0,
            skippedFrames: 0,
            totalLogicTime: 0,
            totalRenderTime: 0,
            maxLogicTime: 0,
            maxRenderTime: 0,
            currentLogicFPS: 0,
            currentRenderFPS: 0,
            averageLogicTime: 0,
            averageRenderTime: 0,
            lastStatsUpdate: 0
        };
    }
    
    /**
     * 获取当前时间戳
     */
    getNow(): number {
        return Date.now();
    }
    
    /**
     * 记录渲染帧
     */
    recordRenderFrame(): void {
        this.stats.renderFrames++;
    }
    
    /**
     * 记录跳帧
     */
    recordSkippedFrame(): void {
        this.stats.skippedFrames++;
    }
    
    /**
     * 记录逻辑帧
     */
    recordLogicFrame(): void {
        this.stats.logicFrames++;
    }
    
    /**
     * 记录逻辑时间
     */
    recordLogicTime(time: number): void {
        this.stats.totalLogicTime += time;
        this.stats.maxLogicTime = Math.max(this.stats.maxLogicTime, time);
    }
    
    /**
     * 记录渲染时间
     */
    recordRenderTime(time: number): void {
        this.stats.totalRenderTime += time;
        this.stats.maxRenderTime = Math.max(this.stats.maxRenderTime, time);
    }
    
    /**
     * 更新统计信息
     */
    updateStats(): void {
        const now = Date.now();
        
        if (now - this.lastStatsResetTime >= this.STATS_UPDATE_INTERVAL) {
            const elapsed = (now - this.lastStatsResetTime) / 1000;
            
            // 计算 FPS
            this.stats.currentLogicFPS = this.stats.logicFrames / elapsed;
            this.stats.currentRenderFPS = this.stats.renderFrames / elapsed;
            
            // 计算平均时间
            if (this.stats.logicFrames > 0) {
                this.stats.averageLogicTime = this.stats.totalLogicTime / this.stats.logicFrames;
            }
            if (this.stats.renderFrames > 0) {
                this.stats.averageRenderTime = this.stats.totalRenderTime / this.stats.renderFrames;
            }
            
            this.stats.lastStatsUpdate = now;
            this.lastStatsResetTime = now;
            
            // 重置计数器（保留 max 值）
            this.stats.logicFrames = 0;
            this.stats.renderFrames = 0;
            this.stats.totalLogicTime = 0;
            this.stats.totalRenderTime = 0;
        }
    }
    
    /**
     * 获取统计信息
     */
    getStats(fixedTimestep: number, accumulator: number, interpolationAlpha: number, enableInterpolation: boolean): any {
        return {
            ...this.stats,
            fixedTimestep,
            targetLogicFPS: 1 / fixedTimestep,
            accumulator,
            interpolationAlpha,
            enableInterpolation
        };
    }
    
    /**
     * 打印统计信息
     */
    printStats(fixedTimestep: number, accumulator: number, interpolationAlpha: number, enableInterpolation: boolean): void {
        const stats = this.getStats(fixedTimestep, accumulator, interpolationAlpha, enableInterpolation);
        
        Log.performance.info('\n=== 固定更新管理器统计 ===');
        Log.performance.info(`逻辑帧率: ${stats.currentLogicFPS.toFixed(2)} FPS (目标: ${stats.targetLogicFPS.toFixed(2)} FPS)`);
        Log.performance.info(`渲染帧率: ${stats.currentRenderFPS.toFixed(2)} FPS`);
        Log.performance.info(`平均逻辑时间: ${stats.averageLogicTime.toFixed(2)}ms`);
        Log.performance.info(`平均渲染时间: ${stats.averageRenderTime.toFixed(2)}ms`);
        Log.performance.info(`最大逻辑时间: ${stats.maxLogicTime.toFixed(2)}ms`);
        Log.performance.info(`最大渲染时间: ${stats.maxRenderTime.toFixed(2)}ms`);
        Log.performance.info(`跳帧次数: ${stats.skippedFrames}`);
        Log.performance.info(`累加器: ${(stats.accumulator * 1000).toFixed(2)}ms`);
        Log.performance.info(`插值因子: ${stats.interpolationAlpha.toFixed(4)}`);
        Log.performance.info(`插值启用: ${stats.enableInterpolation ? '是' : '否'}`);
        Log.performance.info('===========================\n');
    }
    
    /**
     * 重置统计信息
     */
    resetStats(): void {
        this.stats = this.createEmptyStats();
        this.lastStatsResetTime = Date.now();
    }
}

